Objects and classes

Introduction to OOP

What is an object?

All values in Python are objects

Objects are instances of a data type

Objects Have Properties

Attributes — data the object stores

Methods — actions the object can perform

What is a class?

A class defines a data type

Classes are blueprints for creating objects

You’ve Used Classes Before

int, str, float, list, bool

These are all classes!

You’ve Used Methods Before

mylist.append("value")

mystring.upper()

myfile.close()

Example: The `Dog` Class

Let’s build a class from scratch

We’ll learn:

How to create (instantiate) objects
How to store data (attributes)
How to add behavior (methods)

Creating a Simple Class

class Dog:
    pass

That’s it! We’ve defined a class.

Creating Objects (Instantiation)

class Dog:
    pass

fido = Dog()
rex = Dog()

Call the class like a function to create an instance

To create an object, we CALL the class like a function. Dog() creates a new Dog object and returns it.

fido and rex are now two separate Dog objects. They’re independent—changing one doesn’t affect the other.

This is called INSTANTIATION—we’re creating an INSTANCE of the Dog class.

Have students try this:

type(fido)   # <class '__main__.Dog'>
type(rex)    # <class '__main__.Dog'>
fido is rex  # False - They're different objects!

Adding Attributes

fido = Dog()
fido.name = "Fido"
fido.age = 3
fido.breed = "Labrador"

print(fido.name)
print(fido.age)

Fido
3

Attributes are accessed with DOT NOTATION: object.attribute

Setting attributes is like setting variables, but the variable lives INSIDE the object.

Each object has its own namespace—its own set of attributes. fido.name and rex.name are completely separate variables.

Have students create another dog with different attributes:

rex = Dog()
rex.name = "Rex"
rex.age = 5
print(fido.name, rex.name)  # Fido Rex

Why is this better than global variables? The data is organized—all info about Fido stays with Fido.

Why Attributes Beat Global Variables

# Messy: global variables
fido_name = "Fido"
fido_age = 3
rex_name = "Rex"
rex_age = 5

# Clean: attributes
fido.name = "Fido"
fido.age = 3
rex.name = "Rex"
rex.age = 5

Adding Methods

class Dog:
    def bark(self):
        print("Woof!")

fido = Dog()
fido.bark()

Woof!

Methods are functions defined inside a class. They describe what the object can DO.

Notice the self parameter—we’ll explain this next. For now, just know that every method needs self as its first parameter.

When you CALL the method, you don’t pass anything for self: fido.bark() not fido.bark(fido). Python fills in self automatically.

Have students add this and try it:

rex = Dog()
rex.bark()  # Woof!

Both dogs can bark! They share the same method definition, but each dog is doing the barking independently.

Understanding `self`

self refers to the object running the method

class Dog:
    def bark(self):
        print(f"{self.name} says Woof!")

fido = Dog()
fido.name = "Fido"
rex = Dog()
rex.name = "Rex"

fido.bark()
rex.bark()

Fido says Woof!
Rex says Woof!

The `init()` Method

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"{self.name} says Woof!")

fido = Dog("Fido", 3)
print(fido.name, fido.age)

Fido 3

Building a Complete Dog

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.hunger = 5  # Scale of 0-10

    def bark(self):
        print(f"{self.name} says Woof!")

    def eat(self):
        self.hunger = max(0, self.hunger - 3)
        print(f"{self.name} ate! Hunger: {self.hunger}")

    def pass_time(self):
        self.hunger = min(10, self.hunger + 1)

Now we have a more interesting Dog! Notice:

init sets THREE attributes, but only takes TWO parameters. hunger starts at 5 for every dog—it doesn’t need to be passed in.
eat() MODIFIES an attribute. The dog gets less hungry (but not below 0).
pass_time() also modifies hunger. The dog gets hungrier (but not above 10).

This is the power of OOP: the dog tracks its own state and has behaviors that change that state.

Have students create a dog and play with it:

buddy = Dog("Buddy", 2)
buddy.hunger  # 5
buddy.eat()   # Buddy ate! Hunger: 2
buddy.pass_time()
buddy.pass_time()
buddy.hunger  # 4

The object remembers its state between method calls. That’s what attributes are for!

Using Our Dog Class

buddy = Dog("Buddy", 2)
buddy.bark()

Buddy says Woof!

buddy.hunger

buddy.eat()
buddy.eat()

Buddy ate! Hunger: 2
Buddy ate! Hunger: 0

buddy.pass_time()
buddy.pass_time()
buddy.hunger

Example: Summary

We built a Dog class with:

Instantiation: Dog("Fido", 3)
Attributes: name, age, hunger
Methods: bark(), eat(), pass_time()

Defining Classes: The Rules

class ClassName:
body

Use CamelCase for class names

The `pass` Statement

pass does nothing—it’s a placeholder

class Blob:
    pass

Use when you need a body but have nothing to put there

Sometimes you need to define a class (or function, or conditional) but you’re not ready to write the body yet.

pass is a "no-op"—no operation. It satisfies Python’s requirement for a body without doing anything.

You’ll use this when: - Sketching out code structure before filling in details - Creating a minimal class that just needs to exist - Leaving a branch empty in a conditional (though usually there’s a better way)

Don’t use pass when you could just omit the branch entirely:

# Bad
if condition:
    do_something()
else:
    pass

# Good
if condition:
    do_something()

Methods Need `self`

class Greeter:
    def greet(self):
        print(f"Hi, I'm {self.name}!")

self = the object running the method

Every method (with rare exceptions) needs self as its first parameter.

When you call obj.method(), Python automatically passes obj as the first argument. That becomes self inside the method.

self is how methods access the object’s attributes and other methods.

Common error: Forgetting self

def greet():  # Wrong! Missing self
    print(f"Hi, I'm {self.name}!")  # NameError: 'self' not defined

Python will say something like "greet() takes 0 positional arguments but 1 was given" because Python tried to pass the object but the function had no parameter for it.

`init()` Initializes Objects

class Greeter:
    def __init__(self, name):
        self.name = name

Called automatically when object is created

init is called the INITIALIZER or CONSTRUCTOR.

Python calls it automatically right after creating a new object. You never call init directly.

Use it to: 1. Set up attributes the object needs 2. Perform any setup actions

Parameters after self become arguments to the class:

Greeter("Alice")  # "Alice" goes to the name parameter

Not every attribute needs a parameter—you can set defaults:

def __init__(self, name):
    self.name = name
    self.greeting_count = 0  # Always starts at 0

Attributes vs Parameters

def __init__(self, name, age):
    self.name = name        # Parameter → Attribute
    self.age = age          # Parameter → Attribute
    self.hunger = 5         # No parameter, default value
    # age + 1               # Could use parameter without storing it

Important distinction that confuses students:

PARAMETERS are the variables in the function signature. They exist only during the function call.

ATTRIBUTES are stored on self. They persist for the life of the object.

You can: - Turn a parameter into an attribute (most common) - Create an attribute without a parameter (default value) - Use a parameter without making it an attribute (rare but valid)

Example of using parameter without storing:

def __init__(self, birth_year):
    self.age = 2024 - birth_year  # Calculate age, don't store birth_year

Class Definition: Summary

class ClassName: to define
ClassName() to instantiate
Methods need self as first parameter
__init__() sets up new objects
Attributes are variables on self

Docstrings for Classes

Document your code for others (and future you)

Class Docstring Format

class Dog:
    """A virtual pet dog that tracks hunger.

    Attributes:
        name (str): the dog's name.
        age (int): the dog's age in years.
        hunger (int): hunger level from 0 (full) to 10 (starving).
    """

Method Docstrings

def eat(self):
    """Feed the dog, reducing hunger by 3.

    Hunger will not go below 0.
    """
    self.hunger = max(0, self.hunger - 3)

Docstrings Must Come First

# Correct - docstring first
def greet(self):
    """Say hello."""
    print("Hello!")

# Wrong - docstring not first
def greet(self):
    print("Hello!")
    """This won't work as a docstring."""

Docstrings: Summary

Class docstrings describe purpose and attributes
Method docstrings describe behavior
Must be the first statement in the body
Use help() to view docstrings

Complete Example

class Dog:
    """A virtual pet dog that tracks hunger.

    Attributes:
        name (str): the dog's name.
        age (int): the dog's age in years.
        hunger (int): hunger level from 0 (full) to 10 (starving).
    """

    def __init__(self, name, age):
        """Create a new Dog.

        Args:
            name (str): the dog's name.
            age (int): the dog's age in years.
        """
        self.name = name
        self.age = age
        self.hunger = 5

Complete Example (continued)

    def bark(self):
        """Make the dog bark."""
        print(f"{self.name} says Woof!")

    def eat(self):
        """Feed the dog, reducing hunger by 3 (minimum 0)."""
        self.hunger = max(0, self.hunger - 3)
        print(f"{self.name} ate! Hunger: {self.hunger}")

    def pass_time(self):
        """Simulate time passing. Increases hunger by 1 (maximum 10)."""
        self.hunger = min(10, self.hunger + 1)

    def status(self):
        """Print the dog's current status."""
        mood = "happy" if self.hunger < 5 else "hungry"
        print(f"{self.name} ({self.age} yrs) - Hunger: {self.hunger} - {mood}")

The methods complete our Dog class.

Each method has a brief docstring explaining what it does.

status() shows a nice pattern—using attributes to compute something (mood) without storing it as another attribute.

Have students type this whole class into a file and experiment:

buddy = Dog("Buddy", 3)
buddy.status()  # Buddy (3 yrs) - Hunger: 5 - hungry
buddy.eat()     # Buddy ate! Hunger: 2
buddy.status()  # Buddy (3 yrs) - Hunger: 2 - happy

This is a complete, well-documented, functional class. Students can use this as a template for their own classes.

OOP: Key Takeaways

Objects combine data and functionality
Classes are blueprints for objects
Attributes store data (self.name)
Methods define behavior (def bark(self))
__init__() initializes new objects

Practice Ideas

Create your own classes:

BankAccount — balance, deposit(), withdraw()
Student — name, grades list, add_grade(), gpa()
Rectangle — width, height, area(), perimeter()